Tail Recursion without Space Leaks

The G-machine (Johnsson, 1987; Peyton Jones, 1987) is a compiled graph reduction machine for lazy functional languages. The G-machine compiler contains many optimisations to improve performance. One set of such optimisations is designed to improve the performance of tail recursive functions. Unfortunately the abstract machine is subject to a space leak—objects are unnecessarily preserved by the garbage collector. This paper analyses why a particular form of space leak occurs in the G-machine, and presents some ideas for fixing this problem. This phenomena in other abstract machines is also examined briefly. 1. Compilers for conventional imperative languages How might a simple Pascal procedure, like the one shown below, be implemented? procedure f; begin ... g; end; Typically the procedure which called f would set up a new stack frame for it, including such information as return addresses and any arguments passed to f. In turn, a naïve implementation of f might set up a further stack frame for g. This is called a tail call. However, it is clearly unnecessary to retain f’s stack frame since its information (apart from the return address) will never be used again. The implementation can be improved by jumping to g rather than calling it. In doing so, the same stack frame, including f’s return address, can be used for g as was used for f. If the tail call is recursive, the situation is called tail recursion, and the effect of jumping rather than calling is to turn recursion into iteration, which can be performed in constant space (Steele, 1977; Bauer, 1982). 2. Simple graph reducers get this optimisation for free Graph reduction (Wadsworth, 1971) is one method of implementing lazy functional languages. The essential idea behind it is as follows: to reduce an expression (1) construct the graph of the expression; (2) unwind the spine of this graph (leaving pointers to vertebrae—application nodes—on the stack) until the object in the function position (the leftmost, outermost term) is discovered; (3) if this object is indeed a function, and all its arguments are present, apply the function to its arguments;